<!DOCTYPE html>
<!--[if lt IE 7]> <html class="no-js lt-ie9 lt-ie8 lt-ie7"> <![endif]-->
<!--[if IE 7]> <html class="no-js lt-ie9 lt-ie8"> <![endif]-->
<!--[if IE 8]> <html class="no-js lt-ie9"> <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js"> <!--<![endif]-->
<head>
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <title>面试  &middot; sitename</title>
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="HandheldFriendly" content="True">
<meta name="MobileOptimized" content="320">
<meta name="viewport" content="width=device-width, initial-scale=1">


<meta name="description" content="面试 description" />

<meta name="keywords" content="three, four, ">


<meta property="og:title" content="面试  &middot; sitename ">
<meta property="og:site_name" content="sitename"/>
<meta property="og:url" content="https://lvzongcheng.gitee.io/tools/%E9%9D%A2%E8%AF%95/" />
<meta property="og:locale" content="en-EN">


<meta property="og:type" content="article" />
<meta property="og:description" content="面试 description"/>
<meta property="og:article:published_time" content="2017-12-14T00:00:00Z" />
<meta property="og:article:modified_time" content="2017-12-14T00:00:00Z" />

  
    
<meta property="og:article:tag" content="three">
    
<meta property="og:article:tag" content="four">
    
  

  

<script type="application/ld+json">
  {
    "@context": "http://schema.org",
    "@type": "Article",
    "headline": "面试",
    "author": {
      "@type": "Person",
      "name": "LvZongCheng"
    },
    "datePublished": "2017-12-14",
    "description": "面试 description",
    "wordCount":  1885 
  }
</script>



<link rel="canonical" href="https://lvzongcheng.gitee.io/tools/%E9%9D%A2%E8%AF%95/" />

<link rel="apple-touch-icon-precomposed" sizes="144x144" href="https://lvzongcheng.gitee.io/touch-icon-144-precomposed.png">
<link href="https://lvzongcheng.gitee.io/favicon.png" rel="icon">

<meta name="generator" content="Hugo 0.60.0" />

  <!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
<script src="https://oss.maxcdn.com/libs/respond.js/1.4.2/respond.min.js"></script>
<![endif]-->

<link href='https://fonts.googleapis.com/css?family=Merriweather:300%7CRaleway%7COpen+Sans' rel='stylesheet' type='text/css'>
<link rel="stylesheet" href="/css/font-awesome.min.css">
<link rel="stylesheet" href="/css/style.css">
<link rel="stylesheet" href="/css/highlight/default.css">

  
  
	<script>
	  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
	  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
	  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
	  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');

	  ga('create', 'Your Google Analytics tracking code', 'auto');
	  ga('send', 'pageview');

	</script>

</head>
<body>
  <main id="main-wrapper" class="container main_wrapper has-sidebar">
    <header id="main-header" class="container main_header">
  <div class="container brand">
  <div class="container title h1-like">
  <a class="baselink" href="https://lvzongcheng.gitee.io">
  LvZongCheng

</a>

</div>

  
<div class="container topline">
  
  淡定 执著 进取 自律


</div>


</div>

  <nav class="container nav primary no-print">
  

<a class="homelink" href="https://lvzongcheng.gitee.io">home</a>


  
<a href="https://lvzongcheng.gitee.io/framework" title="Show list of Frameworks">Frameworks</a>

<a href="https://lvzongcheng.gitee.io/java" title="Show list of Java">Java</a>

<a href="https://lvzongcheng.gitee.io/linux" title="Show list of Linux">Linux</a>

<a href="https://lvzongcheng.gitee.io/redis" title="Show list of Redis">Redis</a>

<a href="https://lvzongcheng.gitee.io/sql" title="Show list of SQL">SQL</a>

<a href="https://lvzongcheng.gitee.io/Spring" title="Show list of Spring">Spring</a>

<a href="https://lvzongcheng.gitee.io/tools" title="Show list of Tools">Tools</a>

<a href="https://lvzongcheng.gitee.io/webpage" title="Show list of WebPage">WebPage</a>

<a href="https://lvzongcheng.gitee.io/information" title="Show list of information">information</a>

<a href="https://lvzongcheng.gitee.io/network" title="Show list of network">network</a>

<a href="https://lvzongcheng.gitee.io/%E5%BE%AE%E6%9C%8D%E5%8A%A1" title="Show list of 微服务">微服务</a>

<a href="https://lvzongcheng.gitee.io/%E6%80%BB%E7%BB%93" title="Show list of 总结">总结</a>

<a href="https://lvzongcheng.gitee.io/%E6%9C%BA%E5%99%A8%E8%87%AA%E5%8A%A8%E5%8C%96" title="Show list of 机器自动化">机器自动化</a>

<a href="https://lvzongcheng.gitee.io/%E6%B1%87%E7%BC%96" title="Show list of 汇编">汇编</a>

<a href="https://lvzongcheng.gitee.io/%E8%AE%B0%E4%BA%8B%E6%9C%AC" title="Show list of 记事本">记事本</a>


</nav>

<div class="container nav secondary no-print">
  
<a id="contact-link-email" class="contact_link" rel="me" aria-label="Email" href="mailto:Lyc19880405@163.com">
  <span class="fa fa-envelope-square"></span></a>



<a id="contact-link-github" class="contact_link" rel="me" aria-label="Github" href="https://github.com/enten/hugo-boilerplate">
  <span class="fa fa-github-square"></span></a>




 


















</div>


  

</header>


<article id="main-content" class="container main_content single">
  <header class="container hat">
  <h1>面试
</h1>

</header>

  <div class="container content">
  <h5 id="heading"></h5>
<ol>
<li>Spring</li>
</ol>
<ul>
<li>IOC：</li>
<li>AOP：</li>
</ul>
<ol start="2">
<li>java</li>
</ol>
<ul>
<li>设计模式
单例
工厂:</li>
<li>Map</li>
<li>反射、类加载器</li>
</ul>
<pre><code>重复提交
</code></pre>
<h6 id="heading1">字节流与字符流区别</h6>
<pre><code>唯一区别在于，字节流操作的最小数据单元是8位字节，字符流操作的最小数据单元是16位字节  
字节流主要由InputStream和OutputStream作为基类  
字符流主要由Reader和Writer作为基类  
新IO
</code></pre>
<h6 id="equals">==和equals区别</h6>
<pre><code>　 1.  == 是一个运算符。
</code></pre>
<p>　　2.  equals则是string对象的方法，可以.（点）出来。
　　
　　Java中的数据类型，可分为两类：</p>
<pre><code>   1.  基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
    他们之间的比较，应用双等号（==）,比较的是他们的值。
   2.  复合数据类型(类)
   当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。；
</code></pre>
<p>　　
　　需注意几点：</p>
<p>　　1、string是一个特殊的引用类型。对于两个字符串的比较，不管是 == 和 equals 这两者比较的都是字符串是否相同；
　　2、当你创建两个string对象时，内存中的地址是不相同的，你可以赋相同的值。
　　所以字符串的内容相同。引用地址不一定相同，（相同内容的对象地址不一定相同），但反过来却是肯定的；
　　3、基本数据类型比较(string 除外) == 和 Equals 两者都是比较值；</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">	<span style="color:#66d9ef">public</span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">main</span><span style="color:#f92672">(</span>String<span style="color:#f92672">[</span><span style="color:#f92672">]</span> args<span style="color:#f92672">)</span><span style="color:#f92672">{</span>  
Integer a <span style="color:#f92672">=</span> 1<span style="color:#f92672">;</span>  
  Integer b <span style="color:#f92672">=</span> 2<span style="color:#f92672">;</span>  
  Integer c <span style="color:#f92672">=</span> 3<span style="color:#f92672">;</span>  
  Integer d <span style="color:#f92672">=</span> 3<span style="color:#f92672">;</span>  
  Integer e <span style="color:#f92672">=</span> 321<span style="color:#f92672">;</span>  
  Integer f <span style="color:#f92672">=</span> 321<span style="color:#f92672">;</span>  
  Long g <span style="color:#f92672">=</span> 3L<span style="color:#f92672">;</span>  
  String s1 <span style="color:#f92672">=</span> <span style="color:#e6db74">&#34;abc&#34;</span><span style="color:#f92672">;</span>  
  String s2 <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> String<span style="color:#f92672">(</span><span style="color:#e6db74">&#34;abc&#34;</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>  
  String s3 <span style="color:#f92672">=</span> <span style="color:#e6db74">&#34;abc&#34;</span><span style="color:#f92672">;</span>  
  System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;1.  &#34;</span><span style="color:#f92672">+</span><span style="color:#f92672">(</span>c <span style="color:#f92672">=</span><span style="color:#f92672">=</span> d<span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>  
  System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;2.  &#34;</span><span style="color:#f92672">+</span><span style="color:#f92672">(</span>e <span style="color:#f92672">=</span><span style="color:#f92672">=</span> f<span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>  
  System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;3.  &#34;</span><span style="color:#f92672">+</span><span style="color:#f92672">(</span>c <span style="color:#f92672">=</span><span style="color:#f92672">=</span> <span style="color:#f92672">(</span>a<span style="color:#f92672">+</span>b<span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>  
  System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;4.  &#34;</span><span style="color:#f92672">+</span><span style="color:#f92672">(</span>c<span style="color:#f92672">.</span><span style="color:#a6e22e">equals</span><span style="color:#f92672">(</span>a<span style="color:#f92672">+</span>b<span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>  
  System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;5.  &#34;</span><span style="color:#f92672">+</span><span style="color:#f92672">(</span>g <span style="color:#f92672">=</span><span style="color:#f92672">=</span> <span style="color:#f92672">(</span>a<span style="color:#f92672">+</span>b<span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>  
  System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;6.  &#34;</span><span style="color:#f92672">+</span><span style="color:#f92672">(</span>g<span style="color:#f92672">.</span><span style="color:#a6e22e">equals</span><span style="color:#f92672">(</span>a<span style="color:#f92672">+</span>b<span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>  
  System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;7.  &#34;</span><span style="color:#f92672">+</span><span style="color:#f92672">(</span>s1 <span style="color:#f92672">=</span><span style="color:#f92672">=</span> s2<span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>  
  System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;8.  &#34;</span><span style="color:#f92672">+</span><span style="color:#f92672">(</span>s1<span style="color:#f92672">.</span><span style="color:#a6e22e">equals</span><span style="color:#f92672">(</span>s2<span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>  
  System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span><span style="color:#e6db74">&#34;9.  &#34;</span><span style="color:#f92672">+</span><span style="color:#f92672">(</span>s1 <span style="color:#f92672">=</span><span style="color:#f92672">=</span> s3<span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
	<span style="color:#f92672">}</span>
</code></pre></div><ol>
<li>true</li>
<li>false</li>
<li>true</li>
<li>true</li>
<li>true</li>
<li>false</li>
<li>false</li>
<li>true</li>
<li>true</li>
</ol>
<p>对象判断 instanceof</p>
<pre><code>3.  Linux
</code></pre>
<h6 id="4--sql">4.  SQL优化</h6>
<ul>
<li>SELECT子句中避免使用 ‘ * ‘</li>
<li>通过内部函数提高SQL效率</li>
<li>使用表的别名(Alias)</li>
<li>用索引提高效率</li>
<li>使用UNION ALL能满足要求的话，务必使用UNION ALL</li>
<li>对Where 语句的法则</li>
<li>
<ol>
<li>避免在WHERE子句中使用in，not  in，or 或者having。
可以使用 exist 和not exist代替 in和not in。<br>
EXISTS与IN的使用效率的问题，通常情况下采用exists要比in效率高，因为IN不走索引，但要看实际情况具体使用：
IN适合于外表大而内表小的情况；EXISTS适合于外表小而内表大的情况。</li>
</ol>
</li>
</ul>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-sql" data-lang="sql"><span style="color:#66d9ef">select</span> <span style="color:#f92672">*</span> <span style="color:#66d9ef">from</span> TableIn <span style="color:#66d9ef">where</span> <span style="color:#66d9ef">exists</span>(<span style="color:#66d9ef">select</span> BID <span style="color:#66d9ef">from</span> TableEx <span style="color:#66d9ef">where</span> BNAME<span style="color:#f92672">=</span>TableIn.ANAME)
<span style="color:#66d9ef">select</span> <span style="color:#f92672">*</span> <span style="color:#66d9ef">from</span> TableIn <span style="color:#66d9ef">where</span> ANAME <span style="color:#66d9ef">in</span>(<span style="color:#66d9ef">select</span> BNAME <span style="color:#66d9ef">from</span> TableEx)
</code></pre></div><ul>
<li>
<ol start="2">
<li>不要以字符格式声明数字，要以数字格式声明字符值。（日期同样）否则会使索引无效，产生全表扫描</li>
</ol>
</li>
<li>
<p>在WHERE 语句中，尽量避免对索引字段进行计算操作</p>
</li>
<li>
<p>UNION 与UNION ALL区别：
UNION 会过滤掉重复记录，</p>
<ol start="5">
<li>
<p>Spring 事务
生命周期</p>
</li>
<li>
<p>前端框架</p>
</li>
<li>
<p>后台其他框架
struts 配置文件
struts2 与springmvc 区别</p>
</li>
<li>
<p>Redis</p>
</li>
<li>
<p>Solr</p>
</li>
</ol>
</li>
</ul>
<h6 id="11sleep--wait-">11.sleep 方法和 wait 方法的区别</h6>
<pre><code>虽然两者都是用来暂停当前运行的线程，但是 sleep() 实际上只是短暂停顿，
因为它不会释放锁，而 wait() 意味着条件等待，这就是为什么该方法要释放锁，
因为只有这样，其他等待的线程才能在满足条件时获取到该锁。
</code></pre>
<h6 id="12stringstringbufferstringbuilder">12.String、StringBuffer、StringBuilder</h6>
<ol>
<li>
<p>可变与不可变
String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。
　　　　private final char value[];
　　StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。
　　　　char[] value;</p>
</li>
<li>
<p>是否多线程安全
String中的对象是不可变的，也就可以理解为常量，显然<code>线程安全</code>。
StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是<code>线程安全的</code>
StringBuilder并没有对方法进行加同步锁，所以是<code>非线程安全的</code></p>
</li>
<li>
<p>StringBuilder与StringBuffer共同点
StringBuilder与StringBuffer有公共父类AbstractStringBuilder(抽象类)。
　　抽象类与接口的其中一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。
　　StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(&hellip;)。只是StringBuffer会在方法上加synchronized关键字，进行同步。
　　<code>注：如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。</code></p>
</li>
</ol>
<h6 id="13">13.编码转换</h6>
<h6 id="14">14.获取当前日期</h6>
<h6 id="15a--a--b--a--b-">15.a = a + b 与 a += b 的区别</h6>
<h5 id="3--java-">3 年工作经验的 Java 面试题</h5>
<h6 id="16-java--gc">16.解释 Java 堆空间及 GC</h6>
<p>当通过 Java 命令启动 Java 进程的时候，会为它分配内存。内存的一部分用于创建
堆空间，当程序中创建对象的时候，就从对空间中分配内存。GC 是 JVM 内部的一
个进程，回收无效对象的内存用于将来的分配</p>
<h6 id="17--java-">17. 怎么获取 Java 程序使用的内存？堆使用的百分比？</h6>
<p>可以通过 java.lang.Runtime 类中与内存相关方法来获取剩余的内存，总内存及最大堆内存。
通过这些方法你也可以获取到堆使用的百分比及堆内存的剩余空间。Runtime.freeMemory() 
方法返回剩余空间的字节数，Runtime.totalMemory() 方法总内存的字节数，Runtime.maxMemory() 
返回最大内存的字节数
<img src="/image/AnAudition/20170603-01.jpg" alt="Alt text"></p>
<h6 id="18java-">18.Java 中堆和栈有什么区别？</h6>
<p>JVM 中堆和栈属于不同的内存区域，使用目的也不同。栈常用于保存方法帧和局部变量，
而对象总是在堆上分配。栈通常都比堆小，也不会在多个线程之间共享，而堆被整个 JVM 的所有线程共享。
<img src="/image/AnAudition/20170603-02.jpg" alt="Alt text"></p>
<h5 id="java-">Java 基本概念面试题</h5>
<h6 id="19-abaequalsb">19. “a==b”和”a.equals(b)”有什么区别</h6>
<p>如果 a 和 b 都是对象，则 a==b 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的同一个对象才会返回 true，而 a.equals(b) 是进行逻辑比较，所以通常需要重写该方法来提供逻辑一致性的比较。例如，String 类重写 equals() 方法，所以可以用于两个不同对象，但是包含的字母相同的比较</p>
<h6 id="20ahashcode--aequalsb-">20.a.hashCode() 有什么用？与 a.equals(b) 有什么关系？(答案)</h6>
<p>hashCode() 方法是相应对象整型的 hash 值。它常用于基于 hash 的集合类，如 Hashtable、HashMap、LinkedHashMap等等。它与 equals() 方法关系特别紧密。根据 Java 规范，两个使用 equal() 方法来判断相等的对象，必须具有相同的 hash code。</p>
<h6 id="21finalfinalize--finally-">21.final、finalize 和 finally 的不同之处？(答案)</h6>
<p>final 是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。finalize 方法是在对象被回收之前调用的方法，给对象自己最后一个复活的机会，但是什么时候调用 finalize 没有保证。finally 是一个关键字，与 try 和 catch 一起用于异常的处理。finally 块一定会被执行，无论在 try 块中是否有发生异常。</p>
<h6 id="22java-">22.Java 中的编译期常量是什么？使用它又什么风险？</h6>
<p>公共静态不可变（public static final ）变量也就是我们所说的编译期常量，这里的 public 可选的。实际上这些变量在编译时会被替换掉，因为编译器知道这些变量的值，并且知道这些变量在运行时不能改变。这种方式存在的一个问题是你使用了一个内部的或第三方库中的公有编译时常量，但是这个值后面被其他人改变了，但是你的客户端仍然在使用老的值，甚至你已经部署了一个新的jar。为了避免这种情况，当你在更新依赖 JAR 文件时，确保重新编译你的程序。</p>
<h5 id="java-1">Java 集合框架的面试题</h5>
<p>这部分也包含数据结构、算法及数组的面试问题</p>
<h6 id="48-listsetmap--queue-">48) List、Set、Map 和 Queue 之间的区别(答案)</h6>
<p>List 是一个有序集合，允许元素重复。它的某些实现可以提供基于下标值的常量访问时间，但是这不是 List 接口保证的。Set 是一个无序集合。</p>
<h6 id="49poll--remove-">49）poll() 方法和 remove() 方法的区别？</h6>
<p>poll() 和 remove() 都是从队列中取出一个元素，但是 poll() 在获取元素失败的时候会返回空，但是 remove() 失败的时候会抛出异常。</p>
<h6 id="50java--linkedhashmap--priorityqueue-">50）Java 中 LinkedHashMap 和 PriorityQueue 的区别是什么？(答案)</h6>
<p>PriorityQueue 保证最高或者最低优先级的的元素总是在队列头部，但是 LinkedHashMap 维持的顺序是元素插入的顺序。当遍历一个 PriorityQueue 时，没有任何顺序保证，但是 LinkedHashMap 课保证遍历顺序是元素插入的顺序。</p>
<h6 id="51arraylist--linkedlist-">51）ArrayList 与 LinkedList 的不区别？(答案)</h6>
<p>最明显的区别是 ArrrayList 底层的数据结构是数组，支持随机访问，而 LinkedList 的底层数据结构书链表，不支持随机访问。使用下标访问一个元素，ArrayList 的时间复杂度是 O(1)，而 LinkedList 是 O(n)。更多细节的讨论参见答案。</p>
<h6 id="52">52）用哪两种方式来实现集合的排序？(答案)</h6>
<p>你可以使用有序集合，如 TreeSet 或 TreeMap，你也可以使用有顺序的的集合，如 list，然后通过 Collections.sort() 来排序。</p>
<h6 id="53java-answer">53）Java 中怎么打印数组？(answer答案)</h6>
<p>你可以使用 Arrays.toString() 和 Arrays.deepToString() 方法来打印数组。由于数组没有实现 toString() 方法，所以如果将数组传递给 System.out.println() 方法，将无法打印出数组的内容，但是 Arrays.toString() 可以打印每个元素。</p>
<h6 id="54java--linkedlist-">54）Java 中的 LinkedList 是单向链表还是双向链表？(答案)</h6>
<p>是双向链表，你可以检查 JDK 的源码。在 Eclipse，你可以使用快捷键 Ctrl + T，直接在编辑器中打开该类。</p>
<h6 id="55java--treemap-">55）Java 中的 TreeMap 是采用什么树实现的？(答案)</h6>
<p>Java 中的 TreeMap 是使用红黑树实现的。</p>
<h6 id="56-hashtable--hashmap-">56) Hashtable 与 HashMap 有什么不同之处？(答案)</h6>
<p>这两个类有许多不同的地方，下面列出了一部分：
a) Hashtable 是 JDK 1 遗留下来的类，而 HashMap 是后来增加的。
b）Hashtable 是同步的，比较慢，但 HashMap 没有同步策略，所以会更快。
c）Hashtable 不允许有个空的 key，但是 HashMap 允许出现一个 null key。</p>
<h6 id="57java--hashsetanswer">57）Java 中的 HashSet，内部是如何工作的？(answer答案)</h6>
<p>HashSet 的内部采用 HashMap来实现。由于 Map 需要 key 和 value，所以所有 key 的都有一个默认 value。类似于 HashMap，HashSet 不允许重复的 key，只允许有一个null key，意思就是 HashSet 中只允许存储一个 null 对象。</p>
<h6 id="58-arraylist-">58）写一段代码在遍历 ArrayList 时移除一个元素？</h6>
<p>该问题的关键在于面试者使用的是 ArrayList 的 remove() 还是 Iterator 的 remove()方法。这有一段示例代码，是使用正确的方式来实现在遍历的过程中移除元素，而不会出现 ConcurrentModificationException 异常的示例代码。</p>
<h6 id="59-foreach-">59）我们能自己写一个容器类，然后使用 for-each 循环码？</h6>
<p>可以，你可以写一个自己的容器类。如果你想使用 Java 中增强的循环来遍历，你只需要实现 Iterable 接口。如果你实现 Collection 接口，默认就具有该属性。</p>
<h6 id="60arraylist--hashmap-">60）<code>ArrayList 和 HashMap 的默认大小是多数？</code></h6>
<p>在 Java 7 中，ArrayList 的默认大小是 10 个元素，HashMap 的默认大小是16个元素（必须是2的幂）。这就是 Java 7 中 ArrayList 和 HashMap 类的代码片段：</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<h6 id="61-hashcode">61）有没有可能两个不相等的对象有有相同的 hashcode？</h6>
<p>有可能，两个不相等的对象可能会有相同的 hashcode 值，这就是为什么在 hashmap 中会有冲突。相等 hashcode 值的规定只是说如果两个对象相等，必须有相同的hashcode 值，但是没有关于不相等对象的任何规定。</p>
<h6 id="62-hash-code-">62）两个相同的对象会有不同的的 hash code 吗？</h6>
<p>不能，根据 hash code 的规定，这是不可能的。</p>
<h6 id="63-hashcode-">63）我们可以在 hashcode() 中使用随机数字吗？</h6>
<p>不行，因为对象的 hashcode 值必须是相同的。参见答案获取更多关于 Java 中重写 hashCode() 方法的知识。</p>
<h6 id="64java-comparator--comparable-">64）Java 中，Comparator 与 Comparable 有什么不同？</h6>
<p>Comparable 接口用于定义对象的自然顺序，而 comparator 通常用于定义用户定制的顺序。Comparable 总是只有一个，但是可以有多个 comparator 来定义对象的顺序。</p>
<h6 id="65-equals--hashcode-">65）为什么在重写 equals 方法的时候需要重写 hashCode 方法？</h6>
<p>因为有强制的规范指定需要同时重写 hashcode 与 equal 是方法，许多容器类，如 HashMap、HashSet 都依赖于 hashcode 与 equals 的规定。</p>
<h5 id="java-io--nio-">Java IO 和 NIO 的面试题</h5>
<p>IO 是 Java 面试中一个非常重要的点。你应该很好掌握 Java IO，NIO，NIO2 以及与操作系统，磁盘 IO 相关的基础知识。下面是 Java IO 中经常问的问题。</p>
<p>66）在我 Java 程序中，我有三个 socket，我需要多少个线程来处理？</p>
<p>67）Java 中怎么创建 ByteBuffer？</p>
<p>68）Java 中，怎么读写 ByteBuffer ？</p>
<p>69）Java 采用的是大端还是小端？</p>
<p>70）ByteBuffer 中的字节序是什么？</p>
<p>71）Java 中，直接缓冲区与非直接缓冲器有什么区别？(答案)</p>
<p>72）Java 中的内存映射缓存区是什么？(answer答案)</p>
<p>73）socket 选项 TCP NO DELAY 是指什么？</p>
<p>74）TCP 协议与 UDP 协议有什么区别？(answer答案)</p>
<p>75）Java 中，ByteBuffer 与 StringBuffer有什么区别？(答案)</p>
<h5 id="java-2">Java 最佳实践的面试问题</h5>
<p>包含 Java 中各个部分的最佳实践，如集合，字符串，IO，多线程，错误和异常处理，设计模式等等。</p>
<p>76）Java 中，编写多线程程序的时候你会遵循哪些最佳实践？(答案)
这是我在写Java 并发程序的时候遵循的一些最佳实践：
a）给线程命名，这样可以帮助调试。
b）最小化同步的范围，而不是将整个方法同步，只对关键部分做同步。
c）如果可以，更偏向于使用 volatile 而不是 synchronized。
d）使用更高层次的并发工具，而不是使用 wait() 和 notify() 来实现线程间通信，如 BlockingQueue，CountDownLatch 及 Semeaphore。
e）优先使用并发集合，而不是对集合进行同步。并发集合提供更好的可扩展性。</p>
<p>77）说出几点 Java 中使用 Collections 的最佳实践(答案)
这是我在使用 Java 中</p>
<h5 id="datetime--calendar-">Date、Time 及 Calendar 的面试题</h5>
<p>82）在多线程环境下，SimpleDateFormat 是线程安全的吗？(答案)
不是，非常不幸，DateFormat 的所有实现，包括 SimpleDateFormat 都不是线程安全的，因此你不应该在多线程序中使用，除非是在对外线程安全的环境中使用，如 将 SimpleDateFormat 限制在 ThreadLocal 中。如果你不这么做，在解析或者格式化日期的时候，可能会获取到一个不正确的结果。因此，从日期、时间处理的所有实践来说，我强力推荐 joda-time 库。</p>
<p>83）Java 中如何格式化一个日期？如格式化为 ddMMyyyy 的形式？(答案)
Java 中，可以使用 SimpleDateFormat 类或者 joda-time 库来格式日期。DateFormat 类允许你使用多种流行的格式来格式化日期。参见答案中的示例代码，代码中演示了将日期格式化成不同的格式，如 dd-MM-yyyy 或 ddMMyyyy。</p>
<p>84）Java 中，怎么在格式化的日期中显示时区？(答案)</p>
<p>85）Java 中 java.util.Date 与 java.sql.Date 有什么区别？(答案)</p>
<p>86）Java 中，如何计算两个日期之间的差距？(程序)</p>
<p>87）Java 中，如何将字符串 YYYYMMDD 转换为日期？(答案)</p>
<h5 id="-oop-">关于 OOP 和设计模式的面试题</h5>
<p>OOP 基础，如类，对象，接口，继承，多态，封装，抽象以及更高级的一些概念，如组合、聚合及关联</p>
<h6 id="java-3">Java 中，抽象类与接口之间有什么不同？</h6>
<h6 id="heading2">什么是“依赖注入”和“控制反转”？为什么有人使用？</h6>
<h6 id="-setter-">构造器注入和 setter 依赖注入，那种方式更好？</h6>
<h6 id="-java-">描述 Java 中的重载和重写</h6>
<h6 id="java-serializable--externalizable-">Java 中，Serializable 与 Externalizable 的区别？(答案)</h6>
<p>Serializable 接口是一个序列化 Java 类的接口，以便于它们可以在网络上传输或者可以将它们的状态保存在磁盘上，是 JVM 内嵌的默认序列化方式，成本高、脆弱而且不安全。Externalizable 允许你控制整个序列化过程，指定特定的二进制格式，增加安全机制。</p>
<h5 id="servletjsp">Servlet和Jsp概念</h5>
<ol>
<li>Servlet
Servlet是一种服务器端的Java应用程序，具有独立于平台和协议的特性，可以生成动态的Web页面。它担当客户请求（Web浏览器或其他HTTP客户程序）与服务器响应（HTTP服务器上的数据库或应用程序）的中间层。 Servlet是位于Web 服务器内部的服务器端的Java应用程序，与传统的从命令行启动的Java应用程序不同，Servlet由Web服务器进行加载，该Web服务器必须包含支持Servlet的Java虚拟机。</li>
<li>JSP
JSP技术使用Java编程语言编写类XML的tags和scriptlets，来封装产生动态网页的处理逻辑。网页还能通过tags和scriptlets访问存在于服务端的资源的应用逻辑。JSP将网页逻辑与网页设计的显示分离，支持可重用的基于组件的设计，使基于Web的应用程序的开发变得迅速和容易。 JSP(JavaServer Pages)是一种动态页面技术，它的主要目的是将表示逻辑从Servlet中分离出来。</li>
</ol>
<h6 id="servletjsp1">Servlet与Jsp区别:</h6>
<ol>
<li>JSP第一次运行的时候会编译成Servlet，驻留在内存中以供调用。</li>
<li>JSP是web开发技术，Servlet是服务器端运用的小程序，我们访问一个JSP页面时，服务器会将这个JSP页面转变成Servlet小程序运行得到结果后，反馈给用户端的浏览器。</li>
<li>Servlet相当于一个控制层再去调用相应的JavaBean处理数据,最后把结果返回给JSP。</li>
<li>Servlet主要用于转向，将请求转向到相应的JSP页面。</li>
<li>JSP更多的是进行页面显示，Servlet更多的是处理业务，即JSP是页面，Servlet是实现JSP的方法。</li>
<li>Servlet可以实现JSP的所有功能，但由于美工使用Servlet做界面非常困难，后来开发了JSP。</li>
<li>JSP技术开发网站的两种模式：JSP + JavaBean；JSP + Servlet + JavaBean（一般在多层应用中, JSP主要用作表现层,而Servlet则用作控制层,因为在JSP中放太多的代码不利于维护，而把这留给Servlet来实现,而大量的重复代码写在JavaBean中）。</li>
<li>二者之间的差别就是，开发界面是JSP直接可以编写。</li>
</ol>
<ul>
<li>比如在JSP中写Table标记：&lt;table&gt;[数据]&lt;/table&gt;；</li>
<li>Servlet需要加入：out.println(“&lt;table&gt;[数据]&lt;/table&gt;”)。</li>
<li>JSP文件在被应用服务器(例如：Tomcat、Resin、Weblogic和Websphere),调用过之后，就被编译成为了Servlet文件。也就是说在网页上显示的其实是Servlet文件。Tomcat下面JSP文件编译之后生成的Servlet文件被放在了work文件夹下，JSP中的HTML代码在Servlet都被out出来，而JSP代码按照标签的不同会放在不同的位置。</li>
</ul>
<ol start="9">
<li>JSP中嵌入JAVA代码，而Servlet中嵌入HTML代码。</li>
<li>在一个标准的MVC架构中，Servlet作为Controller接受用户请求并转发给相应的Action处理，JSP作为View主要用来产生动态页面，EJB作为Model实现你的业务代码。</li>
</ol>
<h6 id="servlet">Servlet生命周期</h6>
<p>Servlet 生命周期：Servlet 加载&mdash;&gt;实例化&mdash;&gt;服务&mdash;&gt;销毁</p>
<h6 id="struts2">Struts2拦截器和过滤器的区别：</h6>
<ol>
<li>
<p>拦截器是基于Java的反射机制的，而过滤器是基于函数回调</p>
</li>
<li>
<p>过滤器依赖与servlet容器，而拦截器不依赖与servlet容器</p>
</li>
<li>
<p>拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用</p>
</li>
<li>
<p>拦截器可以访问action上下文、值栈里的对象，而过滤器不能</p>
</li>
<li>
<p>在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次</p>
</li>
</ol>
<p>拦截器 ：是在面向切面编程的就是在你的service或者一个方法前调用一个方法，或者在方法后调用
一个方法比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），
也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。</p>
<hr>
<hr>
<h6 id="spring">Spring的优点有什么?</h6>
<ol>
<li>Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分</li>
<li>Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高</li>
<li>依赖注入和IoC使得JDBC操作简单化</li>
<li>Spring是开源的免费的</li>
<li>Spring使得对象管理集中化合简单化</li>
</ol>
<h6 id="springdidependency-injection">描述一下spring中实现DI（dependency injection）的几种方式</h6>
<p>方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。
方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去<br>
方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入<br>
Spring的方式</p>
<h6 id="iocinversion-of-control">简单描述下IOC(inversion of control)的理解</h6>
<p>一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C的实例，但这种方法显然两者的依赖（Dependency）太大了。而IoC的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的实现C放入IoC的 容器（Container）中，通过一定的配置由容器（Container）来实现类A与接口B的实现C的关联。</p>
<h6 id="springormspringhibernate">Spring对很多ORM框架提供了很好支持，描述下在spring使用hibernate的方法</h6>
<p>在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor</p>
<h6 id="spring1">请介绍下spring的事务管理</h6>
<p>spring提供了几个关于事务处理的类：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">TransactionDefinition <span style="color:#75715e">//事务属性定义
</span><span style="color:#75715e"></span>TranscationStatus <span style="color:#75715e">//代表了当前的事务，可以提交，回滚。
</span><span style="color:#75715e"></span>PlatformTransactionManager这个是spring提供的用于管理事务的基础接口<span style="color:#960050;background-color:#1e0010">，</span>其下有一个实现的抽象类AbstractPlatformTransactionManager<span style="color:#f92672">,</span>我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类<span style="color:#960050;background-color:#1e0010">。</span>
</code></pre></div><p>一般事务定义步骤：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml">TransactionDefinition td = new TransactionDefinition();
TransactionStatus ts = transactionManager.getTransaction(td);
try
{ //do sth
transactionManager.commit(ts);
}
catch(Exception e){transactionManager.rollback(ts);}
</code></pre></div><p>spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。
编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">void</span> <span style="color:#a6e22e">add</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span>
<span style="color:#f92672">{</span>
transactionTemplate<span style="color:#f92672">.</span><span style="color:#a6e22e">execute</span><span style="color:#f92672">(</span> <span style="color:#66d9ef">new</span> TransactionCallback<span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">{</span>
pulic Object <span style="color:#a6e22e">doInTransaction</span><span style="color:#f92672">(</span>TransactionStatus ts<span style="color:#f92672">)</span>
<span style="color:#f92672">{</span> <span style="color:#75715e">//do sth}
</span><span style="color:#75715e"></span><span style="color:#f92672">}</span>
<span style="color:#f92672">}</span>
</code></pre></div><p>声明式：
使用TransactionProxyFactoryBean:</p>
<p>PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly 
围绕Poxy的动态代理 能够自动的提交和回滚事务<br>
org.springframework.transaction.interceptor.TransactionProxyFactoryBean<br>
PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。<br>
PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。 
PROPAGATION_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。 
PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务，把当前事务挂起。 
PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。 
PROPAGATION_NESTED–如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。</p>
<h6 id="springapplicationcontextxmljndidatasource">如何在spring的applicationContext.xml使用JNDI而不是DataSource</h6>
<p>可以使用”org.springframework.jndi.JndiObjectFactoryBean”来实现。示例如下：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”dataSource”</span><span style="color:#f92672">&gt;</span>
    <span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”jndiName”</span><span style="color:#f92672">&gt;</span>
        <span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>java:comp/env/jdbc/appfuse<span style="color:#f92672">&lt;/value&gt;</span>
    <span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
</code></pre></div><h6 id="spring2">在spring中是如何配置数据库驱动的</h6>
<p>org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”dataSource”</span><span style="color:#f92672">&gt;</span>
    <span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”driverClassName”</span><span style="color:#f92672">&gt;</span>
        <span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>org.hsqldb.jdbcDriver<span style="color:#f92672">&lt;/value&gt;</span>
    <span style="color:#f92672">&lt;/property&gt;</span>
    <span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”url”</span><span style="color:#f92672">&gt;</span>
        <span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>jdbc:hsqldb:db/appfuse<span style="color:#f92672">&lt;/value&gt;</span>
    <span style="color:#f92672">&lt;/property&gt;</span>
    <span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”username”</span><span style="color:#f92672">&gt;</span><span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>sa<span style="color:#f92672">&lt;/value&gt;</span><span style="color:#f92672">&lt;/property&gt;</span>
    <span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”password”</span><span style="color:#f92672">&gt;</span><span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span><span style="color:#f92672">&lt;/value&gt;</span><span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
</code></pre></div><h6 id="springapplicationcontextxml">spring中的applicationContext.xml能不能改为其他名字</h6>
<p>ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下， 它会在WEB-INF/applicationContext.xml文件找Spring的配置。 你可以通过定义一个<!-- raw HTML omitted -->元素名字为”contextConfigLocation”来改变Spring配置文件的位置。示例如下：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;listener</span><span style="color:#f92672">&gt;</span>
    <span style="color:#f92672">&lt;listener-class</span><span style="color:#f92672">&gt;</span>org.springframework.web.context.ContextLoaderListener
 
    <span style="color:#f92672">&lt;context-param</span><span style="color:#f92672">&gt;</span>
        <span style="color:#f92672">&lt;param-name</span><span style="color:#f92672">&gt;</span>contextConfigLocation<span style="color:#f92672">&lt;/param-name&gt;</span>
        <span style="color:#f92672">&lt;param-value</span><span style="color:#f92672">&gt;</span>/WEB-INF/xyz.xml<span style="color:#f92672">&lt;/param-value&gt;</span>
    <span style="color:#f92672">&lt;/context-param&gt;</span>
 
    <span style="color:#f92672">&lt;/listener-class&gt;</span>
<span style="color:#f92672">&lt;/listener&gt;</span>
</code></pre></div><h6 id="webspring">在web中如何配置spring</h6>
<p>在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;listener</span><span style="color:#f92672">&gt;</span>
    <span style="color:#f92672">&lt;listener-class</span><span style="color:#f92672">&gt;</span>org.springframework.web.context.ContextLoaderListener<span style="color:#f92672">&lt;/listener-class&gt;</span>
<span style="color:#f92672">&lt;/listener&gt;</span>
</code></pre></div><h6 id="springhibernate-mapping">在spring中如何定义hibernate Mapping？</h6>
<p>添加hibernate mapping 文件到web/WEB-INF目录下的applicationContext.xml文件里面。示例如下：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”mappingResources”</span><span style="color:#f92672">&gt;</span>
    <span style="color:#f92672">&lt;list</span><span style="color:#f92672">&gt;</span>
        <span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>org/appfuse/model/User.hbm.xml<span style="color:#f92672">&lt;/value&gt;</span>
    <span style="color:#f92672">&lt;/list&gt;</span>
<span style="color:#f92672">&lt;/property&gt;</span>
</code></pre></div><h6 id="heading3">两种依赖注入的类型是什么?</h6>
<p>两种依赖注入的类型分别是setter注入和构造方法注入。
setter注入： 一般情况下所有的java bean, 我们都会使用setter方法和getter方法去设置和获取属性的值，示例如下：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">namebean</span> <span style="color:#f92672">{</span>
     String      name<span style="color:#f92672">;</span>  
     <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">setName</span><span style="color:#f92672">(</span>String a<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
        name <span style="color:#f92672">=</span> a<span style="color:#f92672">;</span> <span style="color:#f92672">}</span>
     <span style="color:#66d9ef">public</span> String <span style="color:#a6e22e">getName</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
        <span style="color:#66d9ef">return</span> name<span style="color:#f92672">;</span> <span style="color:#f92672">}</span>
    <span style="color:#f92672">}</span>
</code></pre></div><p>我们会创建一个bean的实例然后设置属性的值，spring的配置文件如下：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”bean1″</span>  <span style="color:#f92672">&gt;</span>
   <span style="color:#f92672">&lt;property</span>   <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”name”</span> <span style="color:#f92672">&gt;</span>
       <span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>tom<span style="color:#f92672">&lt;/value&gt;</span>
   <span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
</code></pre></div><p>Spring会调用setName方法来只是name熟悉为tom
构造方法注入：构造方法注入中，我们使用带参数的构造方法如下：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">namebean</span> <span style="color:#f92672">{</span>
     String name<span style="color:#f92672">;</span>
     <span style="color:#66d9ef">public</span> <span style="color:#a6e22e">namebean</span><span style="color:#f92672">(</span>String a<span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
        name <span style="color:#f92672">=</span> a<span style="color:#f92672">;</span>
     <span style="color:#f92672">}</span>   
<span style="color:#f92672">}</span>
</code></pre></div><p>我们会在创建bean实例的时候以new namebean(”tom”)的方式来设置name属性, Spring配置文件如下：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”bean1″</span> <span style="color:#f92672">&gt;</span>
    <span style="color:#f92672">&lt;constructor-arg</span><span style="color:#f92672">&gt;</span>
       <span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>My Bean Value<span style="color:#f92672">&lt;/value&gt;</span>
   <span style="color:#f92672">&lt;/constructor-arg&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
</code></pre></div><p>使用constructor-arg标签来设置构造方法的参数。</p>
<h6 id="dependency-injectiondiiocinversion-of-control">解释一下Dependency Injection(DI)和IOC（inversion of control）?</h6>
<p>参考答案：依赖注入DI是一个程序设计模式和架构模型， 一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个IOC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：把一个数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖
应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转</p>
<h6 id="springbeanfactoryapplicationcontext">Spring中BeanFactory和ApplicationContext的作用和区别</h6>
<p>作用：</p>
<ol>
<li>BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。</li>
<li>ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能：
a. 国际化支持
b. 资源访问：Resource rs = ctx. getResource(”classpath:config.properties”), “file:c:/config.properties”
c. 事件传递：通过实现ApplicationContextAware接口</li>
<li>常用的获取ApplicationContext的方法：
FileSystemXmlApplicationContext：从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组
ClassPathXmlApplicationContext：从classpath的xml配置文件创建，可以从jar包中读取配置文件
WebApplicationContextUtils：从web应用的根目录读取配置文件，需要先在web.xml中配置，可以配置监听器或者servlet来实现</li>
</ol>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;listener</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;listener-class</span><span style="color:#f92672">&gt;</span>org.springframework.web.context.ContextLoaderListener<span style="color:#f92672">&lt;/listener-class&gt;</span>
<span style="color:#f92672">&lt;/listener&gt;</span>
<span style="color:#f92672">&lt;servlet</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;servlet-name</span><span style="color:#f92672">&gt;</span>context<span style="color:#f92672">&lt;/servlet-name&gt;</span>
<span style="color:#f92672">&lt;servlet-class</span><span style="color:#f92672">&gt;</span>org.springframework.web.context.ContextLoaderServlet<span style="color:#f92672">&lt;/servlet-class&gt;</span>
<span style="color:#f92672">&lt;load-on-startup</span><span style="color:#f92672">&gt;</span>1<span style="color:#f92672">&lt;/load-on-startup&gt;</span>
<span style="color:#f92672">&lt;/servlet&gt;</span>
</code></pre></div><p>这两种方式都默认配置文件为web-inf/applicationContext.xml，也可使用context-param指定配置文件</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;context-param</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;param-name</span><span style="color:#f92672">&gt;</span>contextConfigLocation<span style="color:#f92672">&lt;/param-name&gt;</span>
<span style="color:#f92672">&lt;param-value</span><span style="color:#f92672">&gt;</span>/WEB-INF/myApplicationContext.xml<span style="color:#f92672">&lt;/param-value&gt;</span>
<span style="color:#f92672">&lt;/context-param&gt;</span>
</code></pre></div><h6 id="webapplicationcontextxml">在web环境下如何配置applicationContext.xml文件</h6>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;listener</span><span style="color:#f92672">&gt;</span>
  <span style="color:#f92672">&lt;listener-class</span><span style="color:#f92672">&gt;</span>
   org.springframework.web.context.ContextLoaderListener
  <span style="color:#f92672">&lt;/listener-class&gt;</span>
 <span style="color:#f92672">&lt;/listener&gt;</span>
</code></pre></div><p> 或：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"> <span style="color:#f92672">&lt;servlet</span><span style="color:#f92672">&gt;</span>
  <span style="color:#f92672">&lt;servlet-name</span><span style="color:#f92672">&gt;</span>context<span style="color:#f92672">&lt;/servlet-name&gt;</span>
   <span style="color:#f92672">&lt;servlet-class</span><span style="color:#f92672">&gt;</span>
    org.springframework.web.context.ContextLoaderServlet
   <span style="color:#f92672">&lt;/servlet-class&gt;</span>
  <span style="color:#f92672">&lt;load-on-startup</span><span style="color:#f92672">&gt;</span>1<span style="color:#f92672">&lt;/load-on-startup&gt;</span>
 <span style="color:#f92672">&lt;/servlet&gt;</span>
</code></pre></div><p> 通过如下方法取出applicationContext实例:</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"> ApplicationContext ac<span style="color:#f92672">=</span>WebApplicationContextUtils<span style="color:#f92672">.</span><span style="color:#a6e22e">getWebApplicationContext</span><span style="color:#f92672">(</span><span style="color:#66d9ef">this</span><span style="color:#f92672">.</span><span style="color:#a6e22e">getServletContext</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
</code></pre></div><h6 id="spring--struts">如何配置spring + struts？</h6>
<p>在struts-config.xml加入一个插件，通过它加载applicationContext.xml
在struts-config.xml修改action-mapping标记，具体action交给了DelegateActionProxy
通过DelegateActionProxy进入一spring的环境。
在spring的applicationContext.xml加入&lt;bean name=”/login” class=”&rdquo; singleton=”false”/&gt;</p>
<h6 id="spring--hibernate">Spring 和 hibernate的配置文件中的主要类型有哪些？如何配置?</h6>
<p>在myeclipse中先加入spring环境再加入hibernate环境。
 如果spring与hibernate结合在一起可以不需要hibernate.cfg.xml文件是否正确?
 spring+hibernate的配置文件中的主要类有那些?如何配置?
  dataSource
  sessionFactory:hibernate.cfg.xml
  transactionManager
  userDao (extends HibernateDaoSupport) 
   sessionFactory
  facade
  proxy
   sessionFactory
   transactionManager
   facade</p>
<h6 id="spring3">在spring中如何配置容器的事物管理，相关的类有哪些?</h6>
<p>Datasouce
   transactionManager
   userDao要注入
    Datasouce
   Proxy代理
    Target:userDao：代理对象(目标对象)
    transactionAttributes(那些方法需要事务处理)
    transactionManager(事务处理服务)</p>
<h6 id="spring4">在spring中如何配代码的事务管理器</h6>
<p>Datasouce
   transactionManager
   userDao要注入
    Datasouce
    transactionManager
  通过如下类实现
    TransactionTemplate
    JdbcTemplate</p>
<h6 id="spring5">Spring中有几种事物管理，分别是什么?</h6>
<p>代码管理的事务处理</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">TransactonTemplate的execute方法中的内部类TransactionCallback中的doInTransaction方法中使用<span style="color:#960050;background-color:#1e0010">。</span>
<span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">make</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span>
 <span style="color:#f92672">{</span> 
  TransactionTemplate jtm<span style="color:#f92672">=</span><span style="color:#66d9ef">new</span> TransactionTemplate<span style="color:#f92672">(</span><span style="color:#66d9ef">this</span><span style="color:#f92672">.</span><span style="color:#a6e22e">getTransactionManager</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
  jtm<span style="color:#f92672">.</span><span style="color:#a6e22e">execute</span><span style="color:#f92672">(</span><span style="color:#66d9ef">new</span> myClass1<span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
 <span style="color:#f92672">}</span>
 <span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">myClass1</span> <span style="color:#66d9ef">implements</span> TransactionCallback
 <span style="color:#f92672">{</span>
  <span style="color:#66d9ef">public</span> Object <span style="color:#a6e22e">doInTransaction</span><span style="color:#f92672">(</span>TransactionStatus trans<span style="color:#f92672">)</span>
  <span style="color:#f92672">{</span>
   JdbcTemplate jdbc<span style="color:#f92672">=</span><span style="color:#66d9ef">new</span> JdbcTemplate<span style="color:#f92672">(</span>dataSource<span style="color:#f92672">)</span><span style="color:#f92672">;</span>
   jdbc<span style="color:#f92672">.</span><span style="color:#a6e22e">execute</span><span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>insert into <span style="color:#a6e22e">customer</span><span style="color:#f92672">(</span>customerName<span style="color:#f92672">)</span> values<span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">’</span>b<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#f92672">)</span><span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
   jdbc<span style="color:#f92672">.</span><span style="color:#a6e22e">execute</span><span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>insert into <span style="color:#a6e22e">customer</span><span style="color:#f92672">(</span>customerName<span style="color:#f92672">)</span> values<span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">’</span>b<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#f92672">)</span><span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
   <span style="color:#66d9ef">return</span> <span style="color:#66d9ef">null</span><span style="color:#f92672">;</span>
  <span style="color:#f92672">}</span>  
 <span style="color:#f92672">}</span>
</code></pre></div><p>   容器管理的事务处理</p>
<h6 id="springjdbcjdbc">spring中的jdbc与传统的jdbc有什么区别?</h6>
<p>Spring的jdbc:节省代码，不管连接(Connection)，不管事务、不管异常、不管关闭(con.close() ps.close )
  JdbcTemplate(dataSource):增、删、改、查
  TransactionTemplate(transactionManager):进行事务处理</p>
<h6 id="spring6">Spring配置的主要标签有什么?有什么作用?</h6>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;beans</span><span style="color:#f92672">&gt;</span>
   <span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">””</span> <span style="color:#a6e22e">class=</span><span style="color:#e6db74">””</span> <span style="color:#a6e22e">init=</span><span style="color:#e6db74">””</span> <span style="color:#a6e22e">destroy=</span><span style="color:#e6db74">””</span> <span style="color:#a6e22e">singleton=</span><span style="color:#e6db74">””</span><span style="color:#f92672">&gt;</span>
    <span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">””</span><span style="color:#f92672">&gt;</span>
     <span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span><span style="color:#f92672">&lt;/value&gt;</span>
    <span style="color:#f92672">&lt;/property&gt;</span>
    <span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">””</span><span style="color:#f92672">&gt;</span>
     <span style="color:#f92672">&lt;ref</span> <span style="color:#960050;background-color:#1e0010">l</span><span style="color:#960050;background-color:#1e0010">o</span><span style="color:#960050;background-color:#1e0010">c</span><span style="color:#960050;background-color:#1e0010">a</span><span style="color:#960050;background-color:#1e0010">l</span><span style="color:#f92672">&gt;</span><span style="color:#f92672">&lt;/ref&gt;</span>
    <span style="color:#f92672">&lt;/property&gt;</span>
   <span style="color:#f92672">&lt;/bean&gt;</span>
<span style="color:#f92672">&lt;/beans&gt;</span>
</code></pre></div><h6 id="spring7">如何在spring中实现国际化?</h6>
<p>在applicationContext.xml加载一个bean</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”messageSource”</span> <span style="color:#a6e22e">class=</span><span style="color:#e6db74">”org.springframework.context.support.ResourceBundleMessageSource”</span><span style="color:#f92672">&gt;</span>
  <span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”basename”</span><span style="color:#f92672">&gt;</span>
   <span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>message<span style="color:#f92672">&lt;/value&gt;</span>
  <span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
</code></pre></div><p> 在src目录下建多个properties文件
 对于非英文的要用native2ascii -encoding gb2312 源  目转化文件相关内容
 其命名格式是message_语言_国家。
 页面中的中显示提示信息，键名取键值。
 当给定国家，系统会自动加载对应的国家的properties信息。
 通过applictionContext.getMessage(“键名”,”参数”,”区域”)取出相关的信息。</p>
<h6 id="spring8">在spring中如何实现事件处理</h6>
<p>事件
  Extends ApplicationEvent
监听器
  Implements ApplicationListener
事件源
  Implements ApplicationContextAware
在applicationContext.xml中配置事件源、监听器
先得到事件源，调用事件源的方法，通知监听器。</p>
<h6 id="springweb">如何将spring加入web容器中</h6>
<p>在web.xml中加入如下同容,在启动web服务器时加载/WEB-INF/applicationContext.xml中的内容。</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;servlet</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;servlet-name</span><span style="color:#f92672">&gt;</span>context<span style="color:#f92672">&lt;/servlet-name&gt;</span>
<span style="color:#f92672">&lt;servlet-class</span><span style="color:#f92672">&gt;</span>
org.springframework.web.context.ContextLoaderServlet
<span style="color:#f92672">&lt;/servlet-class&gt;</span>
<span style="color:#f92672">&lt;load-on-startup</span><span style="color:#f92672">&gt;</span>1<span style="color:#f92672">&lt;/load-on-startup&gt;</span>
<span style="color:#f92672">&lt;/servlet&gt;</span>
</code></pre></div><p>通过如下类得到ApplicationContext实例
   WebApplicationContextUtils.getWebApplicationContext</p>
<h6 id="spring9">Spring如何实现资源管理?</h6>
<p>使用
applicationContext.getResource(“classpath:文件名”):在src根目录下，在类路径下
applicationContext.getResource(“classpath:/chap01/文件名”): 以src根目录下的基准往下走。
applicationContext.getResource(“file:c:/a.properties”)：在系统文件目录下。</p>
<h6 id="springapplicationcontext">Spring的ApplicationContext的作用?</h6>
<p>beanFactory
国际化(getMesage)
资源管理:可以直接读取一个文件的内容(getResource)
加入web框架中(加入一个servlet或监听器)
事件处理</p>
<h6 id="spring10">spring的核心是什么，各有什么作用？</h6>
<p>BeanFactory：产生一个新的实例，可以实现单例模式
BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能</p>
<h6 id="springaop">Spring中aop的关键名词有哪些？各有什么作用?</h6>
<p>拦截器: 代理
装备(advice)
目标对象
关切点:条件
连接点:方法、属性</p>
<h6 id="springstruts">Spring与struts的区别？</h6>
<p>strusts：是一种基于MVC模式的一个web层的处理。
Spring:提供了通用的服务，ioc/di aop,关心的不仅仅web层，应当j2ee整体的一个服务，可以很容易融合不同的技术struts hibernate ibatis ejb remote springJDBC springMVC</p>
<h6 id="springstruts1">spring与struts的面试题</h6>
<p>1.struts
Action是不是线程安全的？如果不是，有什么方式可以保证Action的线程安全？如果是，说明原因
2.MVC，分析一下struts是如何实现MVC的
3.struts中的几个关键对象的作用(说说几个关键对象的作用)
4.spring
说说AOP和IOC的概念以及在spring中是如何应用的
5.Hibernate有哪几种查询数据的方式
6.load()和get()的区别
回答：
1.Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）
2.struts是用一组类,servlet 和jsp规范实现mvc的
3.ActionFrom ActionServlet Action struts-config.xml
4.spring的核心就是IOC,通过指定对象的创建办法,描述对象与服务之间的关系,而不生成对象
5.3种,hql 条件查询() 原生sql
6.load()方法认为该数据一定存在,可以放心的使用代理来延时加载 ,如果使用过程中发现了问题,就抛出异常;
get()方法一定要获取到真实的数据,否则返回null</p>
<h5 id="spring-hibernate-struts">Spring, hibernate ,struts面试题</h5>
<h6 id="hibernate">Hibernate工作原理及为什么要用？</h6>
<p>原理：</p>
<ol>
<li>读取并解析配置文件</li>
<li>读取并解析映射信息，创建SessionFactory</li>
<li>打开Sesssion</li>
<li>创建事务Transation</li>
<li>持久化操作</li>
<li>提交事务</li>
<li>关闭Session</li>
<li>关闭SesstionFactory
为什么要用：</li>
</ol>
<ul>
<li>对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。</li>
<li>Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作</li>
<li>hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。</li>
<li>hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。
Hibernate是如何延迟加载?</li>
<li>Hibernate2延迟加载实现：a)实体对象  b)集合（Collection）</li>
<li>Hibernate3 提供了属性的延迟加载功能
当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。
Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、
说下Hibernate的缓存机制</li>
<li>内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存</li>
<li>二级缓存：
a)应用及缓存
b)分布式缓存
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非              关键数据
c)  第三方缓存的实现
Hibernate的查询方式
Sql、Criteria,object comptosition
Hql：</li>
<li>属性查询</li>
<li>参数查询、命名参数查询</li>
<li>关联查询</li>
<li>分页查询</li>
<li>统计函数
如何优化Hibernate？</li>
<li>使用双向一对多关联，不使用单向一对多</li>
<li>灵活使用单向一对多关联</li>
<li>不用一对一，用多对一取代</li>
<li>配置对象缓存，不使用集合缓存</li>
<li>一对多集合使用Bag,多对多集合使用Set</li>
<li>继承类使用显式多态</li>
<li>表字段要少，表关联不要怕多，有二级缓存撑腰</li>
</ul>
<h6 id="strutsstruts">Struts工作机制？为什么要使用Struts？</h6>
<p>工作机制：
Struts的工作流程:
在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将执行如下流程.
(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;
(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;
(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;
(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件;
(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
为什么要用：
JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。
基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件
Struts的validate框架是如何验证的？
在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。
说下Struts的设计模式
MVC模式:  web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml 文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果 Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。Execute（）从 ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给 ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。
单例模式
Factory(工厂模式)：
定义一个基类===》实现基类方法（子类通过不同的方法）===》定义一个工厂类（生成子类实例）
===》开发人员调用基类方法
Proxy(代理模式)
spring工作机制及为什么要用?
1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
3.DispatcherServlet请请求提交到目标Controller
4.Controller进行业务逻辑处理后，会返回一个ModelAndView
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
6.视图对象负责渲染返回给客户端。
为什么用：
AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务   （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。
IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反      过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用     其协作对象构造的。因此是由容器管理协作对象（collaborator）。
Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。</p>
<h6 id="springhibernate">一些spring与hibernate的面试题</h6>
<p>1、 简述你对IoC（Inversion of Control）的理解，描述一下Spring中实现DI（Dependency Injection）的几种方式。
2、 Spring的Bean有多种作用域，包括：
singleton、prototype、request、session、global session、application、自定义
3、 简单描述Spring framework与Struts的不同之处，整合Spring与Struts有哪些方法，哪种最好，为什么？
4、 Hibernate中的update()和saveOrUpdate()的区别
5、 Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法，并结合事务管理。
答案：
1、好莱坞原则€€€€不要打电话找我，我会打给你的。IoC将创建的职责从应用程序代码搬到了框架中。Spring对Setter注入和构造方法注入提供支持。（详见http://martinfowler.com/articles/injection.html，以及http: //www.redsaga.com/spring_ref/2.0/html/beans.html#beans-factory- collaborators）
2、 除application（详见Spring framework 2.0 Reference的3.4节bean的作用域）
3、 Spring是完整的一站式框架，而Struts仅是MVC框架，且着重于MVC中的C。Spring有三种方式整合Struts：使用 Spring 的 ActionSupport 类整合 Struts；使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor；将 Struts Action 管理委托给 Spring 框架，动作委托最好。（详见使用Spring 更好地处理Struts 动作）
Spring 2.0新增一种方式：AutowiringRequestProcessor。（详见http://www.javaeye.com/topic/24239）
4、 saveOrUpdate()方法可以实现update()的功能，但会多些步骤，具体如下：
如果对象在该session中已经被持久化，不进行操作；
对象的标识符属性(identifier property)在数据库中不存在或者是个暂时的值，调用save()方法保存它；
如果session中的另一个对象有相同的标识符抛出一个异常；
以上皆不符合则调用update()更新之。
5、 在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。
在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。（详见Spring framework 2.0 Reference的12.2节Hibernate）
声明式事务需声明事务管理器，在context中设置指定属性，用确定和。</p>
<h6 id="springjdbc">在spring中如何更加高效的使用JDBC</h6>
<p>使用Spring框架提供的模板类JdbcTemplete可以是JDBC更加高效
代码如下：JdbcTemplate template = new JdbcTemplate(myDataSource);
DAO类的例子：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml">public class StudentDaoJdbc implements StudentDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
more..
}
</code></pre></div><p>配置文件：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”jdbcTemplate”</span> <span style="color:#a6e22e">class=</span><span style="color:#e6db74">”org.springframework.jdbc.core.JdbcTemplate”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”dataSource”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;ref</span> <span style="color:#a6e22e">bean=</span><span style="color:#e6db74">”dataSource”/</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
<span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”studentDao”</span> <span style="color:#a6e22e">class=</span><span style="color:#e6db74">”StudentDaoJdbc”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”jdbcTemplate”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;ref</span> <span style="color:#a6e22e">bean=</span><span style="color:#e6db74">”jdbcTemplate”/</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
<span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”courseDao”</span> <span style="color:#a6e22e">class=</span><span style="color:#e6db74">”CourseDaoJdbc”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”jdbcTemplate”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;ref</span> <span style="color:#a6e22e">bean=</span><span style="color:#e6db74">”jdbcTemplate”/</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
</code></pre></div><h6 id="spring11">在spring如何创建一个数据连接池</h6>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”dataSource”</span> <span style="color:#a6e22e">class=</span><span style="color:#e6db74">”org.apache.commons.dbcp.BasicDataSource”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”driver”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>${db.driver}<span style="color:#f92672">&lt;/value&gt;</span>
<span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”url”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>${db.url}<span style="color:#f92672">&lt;/value&gt;</span>
<span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”username”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>${db.username}<span style="color:#f92672">&lt;/value&gt;</span>
<span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”password”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>${db.password}<span style="color:#f92672">&lt;/value&gt;</span>
<span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
</code></pre></div><h6 id="springbeanjndidatasource">在spring中如何配置一个bean来从JNDI到dataSource</h6>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”dataSource”</span> <span style="color:#a6e22e">class=</span><span style="color:#e6db74">”org.springframework.jndi.JndiObjectFactoryBean”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;property</span> <span style="color:#a6e22e">name=</span><span style="color:#e6db74">”jndiName”</span><span style="color:#f92672">&gt;</span> <span style="color:#f92672">&lt;value</span><span style="color:#f92672">&gt;</span>java:comp/env/jdbc/myDatasource<span style="color:#f92672">&lt;/value&gt;</span>
<span style="color:#f92672">&lt;/property&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
</code></pre></div><h6 id="springbean">请介绍下spring中bean的作用域</h6>
<p>在spring2.0之前bean只有2种作用域即：singleton(单例)、non-singleton（也称 prototype），Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此，默认情况下Spring2.0现在有五种类型的Bean。</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”role”</span> <span style="color:#a6e22e">class=</span><span style="color:#e6db74">”spring.chapter2.maryGame.Role”</span> <span style="color:#a6e22e">scope=</span><span style="color:#e6db74">”singleton”/</span><span style="color:#f92672">&gt;</span>
</code></pre></div><p>这里的scope就是用来配置spring bean的作用域，它标识bean的作用域。
在spring2.0之前bean只有2种作用域即：singleton(单例)、non-singleton（也称 prototype），Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此，默认情况下Spring2.0现在有五种类型的Bean。当然，Spring2.0对 Bean的类型的设计进行了重构，并设计出灵活的Bean类型支持，理论上可以有无数多种类型的Bean，用户可以根据自己的需要，增加新的Bean类型，满足实际应用需求。</p>
<ol>
<li>singleton作用域<br>
当一个bean的作用域设置为singleton，那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。换言之，当把一个bean定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例，这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的，单例设计模式表示一个ClassLoader中只有一个class存在，而这里的singleton则表示一个容器对应一个bean，也就是说当一个bean被标识为singleton时候，spring的IOC容器中只会存在一个该bean。<br>
配置实例：</li>
</ol>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<p>或者</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<ol start="2">
<li>prototype<br>
prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）都会产生一个新的bean实例，相当于一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个 prototype bean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的职责。（让Spring容器释放被singleton作用域bean占用资源的一种可行方式是，通过使用 bean的后置处理器，该处理器持有要被清除的bean的引用。）<br>
配置实例：</li>
</ol>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<p>或者</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<ol start="3">
<li>request<br>
request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效，配置实例：
request、session、global session使用的时候，首先要在初始化web的web.xml中做如下配置：
如果你使用的是Servlet 2.4及以上的web容器，那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可：</li>
</ol>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<p>如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现：</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<p>接着既可以配置bean的作用域了：</p>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<ol start="4">
<li>session<br>
session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效，配置实例：
配置实例：
和request配置实例的前提一样，配置好web启动文件就可以如下配置：</li>
</ol>
<!-- raw HTML omitted -->
<!-- raw HTML omitted -->
<ol start="5">
<li>global session<br>
global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个 portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean，那么，web会自动当成session类型来使用。
配置实例：
和request配置实例的前提一样，配置好web启动文件就可以如下配置：
&lt;bean id=”role” class=”spring.chapter2.maryGame.Role” scope=”global session”/&gt;</li>
<li>自定义bean装配作用域<br>
在spring 2.0中作用域是可以任意扩展的，你可以自定义作用域，甚至你也可以重新定义已有的作用域（但是你不能覆盖singleton和 prototype），spring的作用域由接口org.springframework.beans.factory.config.Scope来定义，自定义自己的作用域只要实现该接口即可，下面给个实例：
我们建立一个线程的scope，该scope在表示一个线程中有效，代码如下：</li>
</ol>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">publicclass MyScope <span style="color:#66d9ef">implements</span> Scope <span style="color:#960050;background-color:#1e0010">…</span><span style="color:#f92672">{</span>
privatefinal ThreadLocal threadScope <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> ThreadLocal<span style="color:#f92672">(</span><span style="color:#f92672">)</span> <span style="color:#960050;background-color:#1e0010">…</span><span style="color:#f92672">{</span>
<span style="color:#66d9ef">protected</span> Object <span style="color:#a6e22e">initialValue</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span> <span style="color:#960050;background-color:#1e0010">…</span><span style="color:#f92672">{</span>
returnnew <span style="color:#a6e22e">HashMap</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
<span style="color:#f92672">}</span>
<span style="color:#f92672">}</span><span style="color:#f92672">;</span>
<span style="color:#66d9ef">public</span> Object <span style="color:#a6e22e">get</span><span style="color:#f92672">(</span>String name<span style="color:#f92672">,</span> ObjectFactory objectFactory<span style="color:#f92672">)</span> <span style="color:#960050;background-color:#1e0010">…</span><span style="color:#f92672">{</span>
Map scope <span style="color:#f92672">=</span> <span style="color:#f92672">(</span>Map<span style="color:#f92672">)</span> threadScope<span style="color:#f92672">.</span><span style="color:#a6e22e">get</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
Object object <span style="color:#f92672">=</span> scope<span style="color:#f92672">.</span><span style="color:#a6e22e">get</span><span style="color:#f92672">(</span>name<span style="color:#f92672">)</span><span style="color:#f92672">;</span>
<span style="color:#66d9ef">if</span><span style="color:#f92672">(</span>object<span style="color:#f92672">=</span><span style="color:#f92672">=</span><span style="color:#66d9ef">null</span><span style="color:#f92672">)</span> <span style="color:#960050;background-color:#1e0010">…</span><span style="color:#f92672">{</span>
object <span style="color:#f92672">=</span> objectFactory<span style="color:#f92672">.</span><span style="color:#a6e22e">getObject</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
scope<span style="color:#f92672">.</span><span style="color:#a6e22e">put</span><span style="color:#f92672">(</span>name<span style="color:#f92672">,</span> object<span style="color:#f92672">)</span><span style="color:#f92672">;</span>
<span style="color:#f92672">}</span>
<span style="color:#66d9ef">return</span> object<span style="color:#f92672">;</span>
<span style="color:#f92672">}</span>
<span style="color:#66d9ef">public</span> Object <span style="color:#a6e22e">remove</span><span style="color:#f92672">(</span>String name<span style="color:#f92672">)</span> <span style="color:#960050;background-color:#1e0010">…</span><span style="color:#f92672">{</span>
Map scope <span style="color:#f92672">=</span> <span style="color:#f92672">(</span>Map<span style="color:#f92672">)</span> threadScope<span style="color:#f92672">.</span><span style="color:#a6e22e">get</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
<span style="color:#66d9ef">return</span> scope<span style="color:#f92672">.</span><span style="color:#a6e22e">remove</span><span style="color:#f92672">(</span>name<span style="color:#f92672">)</span><span style="color:#f92672">;</span>
<span style="color:#f92672">}</span>
publicvoid <span style="color:#a6e22e">registerDestructionCallback</span><span style="color:#f92672">(</span>String name<span style="color:#f92672">,</span> Runnable callback<span style="color:#f92672">)</span> <span style="color:#960050;background-color:#1e0010">…</span><span style="color:#f92672">{</span>
<span style="color:#f92672">}</span>
<span style="color:#66d9ef">public</span> String <span style="color:#a6e22e">getConversationId</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span> <span style="color:#960050;background-color:#1e0010">…</span><span style="color:#f92672">{</span>
<span style="color:#75715e">// TODO Auto-generated method stub
</span><span style="color:#75715e"></span>returnnull<span style="color:#f92672">;</span>
<span style="color:#f92672">}</span>
<span style="color:#f92672">}</span>
</code></pre></div><h6 id="-springbean">请介绍 一下spring的bean的生命周期</h6>
<p>一、Bean的定义
Spring通常通过配置文件定义Bean。如：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#f92672">&lt;</span><span style="color:#f92672">?</span>xml version<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>1<span style="color:#f92672">.</span><span style="color:#a6e22e">0</span><span style="color:#960050;background-color:#1e0010">″</span> encoding<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>UTF<span style="color:#f92672">-</span>8<span style="color:#960050;background-color:#1e0010">″</span><span style="color:#f92672">?</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;</span>beans xmlns<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>http<span style="color:#f92672">:</span><span style="color:#75715e">//www.springframework.org/schema/beans”
</span><span style="color:#75715e"></span>xmlns:xsi<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>http<span style="color:#f92672">:</span><span style="color:#75715e">//www.w3.org/2001/XMLSchema-instance”
</span><span style="color:#75715e"></span>xsi:schemaLocation<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>http<span style="color:#f92672">:</span><span style="color:#75715e">//www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd”&gt;
</span><span style="color:#75715e"></span><span style="color:#f92672">&lt;</span>bean id<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>HelloWorld<span style="color:#960050;background-color:#1e0010">”</span> class<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>com<span style="color:#f92672">.</span><span style="color:#a6e22e">pqf</span><span style="color:#f92672">.</span><span style="color:#a6e22e">beans</span><span style="color:#f92672">.</span><span style="color:#a6e22e">HelloWorld</span><span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;</span>property name<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>msg<span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;</span>value<span style="color:#f92672">&gt;</span>HelloWorld<span style="color:#f92672">&lt;</span><span style="color:#f92672">/</span>value<span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;</span><span style="color:#f92672">/</span>property<span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;</span><span style="color:#f92672">/</span>bean<span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;</span><span style="color:#f92672">/</span>beans<span style="color:#f92672">&gt;</span>
</code></pre></div><p>这个配置文件就定义了一个标识为 HelloWorld 的Bean。在一个配置文档中可以定义多个Bean。
二、Bean的初始化
有两种方式初始化Bean。
1、在配置文档中通过指定init-method 属性来完成
在Bean的类中实现一个初始化Bean属性的方法，如init()，如：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">HelloWorld</span><span style="color:#f92672">{</span>
<span style="color:#66d9ef">public</span> String msg<span style="color:#f92672">=</span><span style="color:#66d9ef">null</span><span style="color:#f92672">;</span>
<span style="color:#66d9ef">public</span> Date date<span style="color:#f92672">=</span><span style="color:#66d9ef">null</span><span style="color:#f92672">;</span>
<span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">init</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
msg<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>HelloWorld<span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">;</span>
date<span style="color:#f92672">=</span><span style="color:#66d9ef">new</span> Date<span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
<span style="color:#f92672">}</span>
<span style="color:#960050;background-color:#1e0010">…</span><span style="color:#960050;background-color:#1e0010">…</span>
<span style="color:#f92672">}</span>
</code></pre></div><p>然后，在配置文件中设置init-mothod属性：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-xml" data-lang="xml"><span style="color:#f92672">&lt;bean</span> <span style="color:#a6e22e">id=</span><span style="color:#e6db74">”HelloWorld”</span> <span style="color:#a6e22e">class=</span><span style="color:#e6db74">”com.pqf.beans.HelloWorld”</span> <span style="color:#a6e22e">init-mothod=</span><span style="color:#e6db74">”init”</span> <span style="color:#f92672">&gt;</span>
<span style="color:#f92672">&lt;/bean&gt;</span>
</code></pre></div><p>2、实现 org.springframwork.beans.factory.InitializingBean接口
Bean实现InitializingBean接口，并且增加 afterPropertiesSet() 方法：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java"><span style="color:#66d9ef">public</span> <span style="color:#66d9ef">class</span> <span style="color:#a6e22e">HelloWorld</span> implement InitializingBean <span style="color:#f92672">{</span>
<span style="color:#66d9ef">public</span> String msg<span style="color:#f92672">=</span><span style="color:#66d9ef">null</span><span style="color:#f92672">;</span>
<span style="color:#66d9ef">public</span> Date date<span style="color:#f92672">=</span><span style="color:#66d9ef">null</span><span style="color:#f92672">;</span>
<span style="color:#66d9ef">public</span> <span style="color:#66d9ef">void</span> <span style="color:#a6e22e">afterPropertiesSet</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span> <span style="color:#f92672">{</span>
msg<span style="color:#f92672">=</span><span style="color:#960050;background-color:#1e0010">”</span>向全世界问好<span style="color:#960050;background-color:#1e0010">！</span><span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">;</span>
date<span style="color:#f92672">=</span><span style="color:#66d9ef">new</span> Date<span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
<span style="color:#f92672">}</span>
<span style="color:#960050;background-color:#1e0010">…</span><span style="color:#960050;background-color:#1e0010">…</span>
<span style="color:#f92672">}</span>
</code></pre></div><p>那么，当这个Bean的所有属性被Spring的BeanFactory设置完后，会自动调用afterPropertiesSet()方法对Bean进行初始化，于是，配置文件就不用指定 init-method属性了。
三、Bean的调用
有三种方式可以得到Bean并进行调用：
1、使用BeanWrapper</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">HelloWorld hw<span style="color:#f92672">=</span><span style="color:#66d9ef">new</span> HelloWorld<span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
BeanWrapper bw<span style="color:#f92672">=</span><span style="color:#66d9ef">new</span> BeanWrapperImpl<span style="color:#f92672">(</span>hw<span style="color:#f92672">)</span><span style="color:#f92672">;</span>
bw<span style="color:#f92672">.</span><span style="color:#a6e22e">setPropertyvalue</span><span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>msg<span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">,</span><span style="color:#960050;background-color:#1e0010">”</span>HelloWorld<span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
system<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span>bw<span style="color:#f92672">.</span><span style="color:#a6e22e">getPropertyCalue</span><span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>msg<span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
</code></pre></div><p>2、使用BeanFactory</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">InputStream is<span style="color:#f92672">=</span><span style="color:#66d9ef">new</span> FileInputStream<span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>config<span style="color:#f92672">.</span><span style="color:#a6e22e">xml</span><span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
XmlBeanFactory factory<span style="color:#f92672">=</span><span style="color:#66d9ef">new</span> XmlBeanFactory<span style="color:#f92672">(</span>is<span style="color:#f92672">)</span><span style="color:#f92672">;</span>
HelloWorld hw<span style="color:#f92672">=</span><span style="color:#f92672">(</span>HelloWorld<span style="color:#f92672">)</span> factory<span style="color:#f92672">.</span><span style="color:#a6e22e">getBean</span><span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>HelloWorld<span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
system<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span>hw<span style="color:#f92672">.</span><span style="color:#a6e22e">getMsg</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
</code></pre></div><p>3、使用ApplicationConttext</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ApplicationContext actx<span style="color:#f92672">=</span><span style="color:#66d9ef">new</span> FleSystemXmlApplicationContext<span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>config<span style="color:#f92672">.</span><span style="color:#a6e22e">xml</span><span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
HelloWorld hw<span style="color:#f92672">=</span><span style="color:#f92672">(</span>HelloWorld<span style="color:#f92672">)</span> actx<span style="color:#f92672">.</span><span style="color:#a6e22e">getBean</span><span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>HelloWorld<span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
System<span style="color:#f92672">.</span><span style="color:#a6e22e">out</span><span style="color:#f92672">.</span><span style="color:#a6e22e">println</span><span style="color:#f92672">(</span>hw<span style="color:#f92672">.</span><span style="color:#a6e22e">getMsg</span><span style="color:#f92672">(</span><span style="color:#f92672">)</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
</code></pre></div><p>四、Bean的销毁
1、使用配置文件中的 destory-method 属性
与初始化属性 init-methods类似，在Bean的类中实现一个撤销Bean的方法，然后在配置文件中通过 destory-method指定，那么当bean销毁时，Spring将自动调用指定的销毁方法。
2、实现 org.springframwork.bean.factory.DisposebleBean接口
如果实现了DisposebleBean接口，那么Spring将自动调用bean中的Destory方法进行销毁，所以，Bean中必须提供Destory方法。</p>
<h6 id="springbean1">Spring中如何获取bean</h6>
<p>通过xml配置文件
bean配置在xml里面，spring提供多种方式读取配置文件得到ApplicationContext.
第一种方式：FileSystemXmlApplicationContext
通过程序在初始化的时候，导入Bean配置文件，然后得到Bean实例:</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ApplicationContext ac <span style="color:#f92672">=</span> <span style="color:#66d9ef">new</span> FileSystemXmlApplicationContext<span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>applicationContext<span style="color:#f92672">.</span><span style="color:#a6e22e">xml</span><span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span>
ac<span style="color:#f92672">.</span><span style="color:#a6e22e">getBean</span><span style="color:#f92672">(</span><span style="color:#960050;background-color:#1e0010">”</span>beanName<span style="color:#960050;background-color:#1e0010">”</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
</code></pre></div><p>第二种方式：WebApplicationContextUtil
在B/S系统中,通常在web.xml初始化bean的配置文件，然后由WebAppliCationContextUtil得到ApplicationContext.例如：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">ApplicationContext ctx <span style="color:#f92672">=</span> WebApplicationContextUtils<span style="color:#f92672">.</span><span style="color:#a6e22e">getRequiredWebApplicationContext</span><span style="color:#f92672">(</span>ServletContext sc<span style="color:#f92672">)</span><span style="color:#f92672">;</span>
ApplicationContext ctx <span style="color:#f92672">=</span>   WebApplicationContextUtils<span style="color:#f92672">.</span><span style="color:#a6e22e">getWebApplicationContext</span><span style="color:#f92672">(</span>ServletContext sc<span style="color:#f92672">)</span><span style="color:#f92672">;</span>
</code></pre></div><p>其中 servletContext sc 可以具体 换成 servlet.getServletContext()或者 this.getServletContext() 或者 request.getSession().getServletContext();
另外，由于spring是注入的对象放在ServletContext中的，所以可以直接在ServletContext取出WebApplicationContext 对象：</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">WebApplicationContext webApplicationContext <span style="color:#f92672">=</span> <span style="color:#f92672">(</span>WebApplicationContext<span style="color:#f92672">)</span> servletContext<span style="color:#f92672">.</span><span style="color:#a6e22e">getAttribute</span><span style="color:#f92672">(</span>WebApplicationContext<span style="color:#f92672">.</span><span style="color:#a6e22e">ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE</span><span style="color:#f92672">)</span><span style="color:#f92672">;</span>
</code></pre></div><h6 id="spring12">Spring框架有哪几部分组成?</h6>
<p>Spring框架有七个模块组成组成，这7个模块(或组件)均可以单独存在，也可以与其它一个或多个模块联合使用，主要功能表现如下：</p>
<ul>
<li>Spring 核心容器（Core）：提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，她是工厂模式的实现。BeanFactory使用控制反转（Ioc）模式将应用程序的配置和依赖性规范与实际的应用代码程序分开。</li>
<li>Spring AOP：通过配置管理特性，Spring AOP模块直接面向方面的编程功能集成到了Spring框架中，所以可以很容易的使Spring框架管理的任何对象支持 AOP。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖于EJB组件，就可以将声明性事务管理集成到应用程序中。</li>
<li>Spring ORM：Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。所有这些都遵从Spring的通用事务和DAO异常层结构。</li>
<li>Spring DAO：JDBC DAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应商抛出的异常错误信息。异常层次结构简化了错误处理，并且大大的降低 了需要编写的异常代码数量（例如，打开和关系连接）。Spring DAO的面向JDBC的异常遵从通用的DAO异常层结构。</li>
<li>Spring WEB：Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用程序提供了上下文的服务。所以Spring框架支持 Jakarta Struts的集成。Web模块还简化了处理多部分请求及将请求参数绑定到域对象的工作。</li>
<li>Spring上下文（Context）：Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化校验和调度功能。</li>
<li>Spring MVC：Spring的MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol</li>
</ul>
<h6 id="spring13">使用spring有什么好处?</h6>
<ul>
<li>Spring能有效地组织你的中间层对象,无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题，。</li>
<li>Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。</li>
<li>Spring能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种 一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？有了Spring，你可 很简单地看到类的JavaBean属性。倒置控制的使用(在下面讨论)帮助完成这种简化。</li>
<li>Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。</li>
<li>Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。</li>
<li>使用Spring构建的应用程序易于单元测试。</li>
<li>Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。</li>
<li>Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。<br>
Spring为数据存取提供了一致的框架,不论是使用JDBC或O/R mapping产品（如Hibernate）。
Spring确实使你能通过最简单可行的解决办法解决你的问题。这些特性是有很大价值的。<br>
总结起来，Spring有如下优点：</li>
<li>低侵入式设计，代码污染极低</li>
<li>独立于各种应用服务器，可以真正实现Write Once,Run Anywhere的承诺</li>
<li>Spring的DI机制降低了业务对象替换的复杂性</li>
<li>Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部</li>
</ul>
<h6 id="spring14">什么是spring，它有什么特点?</h6>
<p>Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。</p>
<ul>
<li>轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并 且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。</li>
<li>控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不 是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。</li>
<li>面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的 业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们 并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。</li>
<li>容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是 一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生 成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。</li>
<li>框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。</li>
</ul>

</div>


  
</article>
      <footer id="main-footer" class="container main_footer">
  

  <div class="container nav foot no-print">
  
<a href="https://lvzongcheng.gitee.io/license">license</a>


  <a class="toplink" href="#">back to top</a>

</div>

  <div class="container credits">
  
<div class="container footline">
  
  code with <!-- raw HTML omitted --><!-- raw HTML omitted -->


</div>


  
<div class="container copyright">
  
  (c) 2015 yourname.


</div>


</div>

</footer>

    </main>
    
<script type="text/javascript">
  (function() {
    
    
    if (window.location.hostname == "localhost")
      return;
    var dsq = document.createElement('script'); dsq.async = true; dsq.type = 'text/javascript';
    dsq.src = '//your_disqus_shortname.disqus.com/count.js';
    (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
  })();
</script>



<script src="/js/highlight.pack.js"></script>
<script>hljs.initHighlightingOnLoad();</script>



    
  </body>
</html>

